/*
 * EcmaScript.java - ScriptME
 * 
 * Copyright (c) 2009 Cesar Henriques <cesar at alttab.com.ar>.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Lesser Public License v2.1
 * which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * 
 * Based on FESI Project
 * 
 * Contributors:
 * 	Jean-Marc Lugrin - initial API and implementation
 * 	Cesar Henriques <cesar at alttab.com.ar> - J2ME Porting and Extensions
 */
package org.scriptme.ecmascript.parser;

import org.scriptme.ecmascript.ast.ASTAllocationExpression;
import org.scriptme.ecmascript.ast.ASTAndExpressionSequence;
import org.scriptme.ecmascript.ast.ASTAssignmentExpression;
import org.scriptme.ecmascript.ast.ASTBinaryExpressionSequence;
import org.scriptme.ecmascript.ast.ASTBreakStatement;
import org.scriptme.ecmascript.ast.ASTCompositeReference;
import org.scriptme.ecmascript.ast.ASTConditionalExpression;
import org.scriptme.ecmascript.ast.ASTContinueStatement;
import org.scriptme.ecmascript.ast.ASTEmptyExpression;
import org.scriptme.ecmascript.ast.ASTExpressionList;
import org.scriptme.ecmascript.ast.ASTForInStatement;
import org.scriptme.ecmascript.ast.ASTForStatement;
import org.scriptme.ecmascript.ast.ASTForVarInStatement;
import org.scriptme.ecmascript.ast.ASTForVarStatement;
import org.scriptme.ecmascript.ast.ASTFormalParameterList;
import org.scriptme.ecmascript.ast.ASTFunctionCallParameters;
import org.scriptme.ecmascript.ast.ASTFunctionDeclaration;
import org.scriptme.ecmascript.ast.ASTIdentifier;
import org.scriptme.ecmascript.ast.ASTIfStatement;
import org.scriptme.ecmascript.ast.ASTLiteral;
import org.scriptme.ecmascript.ast.ASTOperator;
import org.scriptme.ecmascript.ast.ASTOrExpressionSequence;
import org.scriptme.ecmascript.ast.ASTPostfixExpression;
import org.scriptme.ecmascript.ast.ASTProgram;
import org.scriptme.ecmascript.ast.ASTPropertyIdentifierReference;
import org.scriptme.ecmascript.ast.ASTPropertyValueReference;
import org.scriptme.ecmascript.ast.ASTReturnStatement;
import org.scriptme.ecmascript.ast.ASTStatement;
import org.scriptme.ecmascript.ast.ASTStatementList;
import org.scriptme.ecmascript.ast.ASTThisReference;
import org.scriptme.ecmascript.ast.ASTUnaryExpression;
import org.scriptme.ecmascript.ast.ASTVariableDeclaration;
import org.scriptme.ecmascript.ast.ASTWhileStatement;
import org.scriptme.ecmascript.ast.ASTWithStatement;
import org.scriptme.ecmascript.ast.EcmaScriptTreeConstants;
import org.scriptme.ecmascript.ast.JJTEcmaScriptState;
import org.scriptme.ecmascript.ast.Node;
import org.scriptme.ecmascript.ast.SimpleNode;

/**
 * The Class EcmaScript.
 */
public class EcmaScript/* @bgen(jjtree) */implements EcmaScriptTreeConstants,
		EcmaScriptConstants {/* @bgen(jjtree) */
	/** The jjtree. */
	protected JJTEcmaScriptState jjtree = new JJTEcmaScriptState();

	/**
	 * Save the current line number for run-time error messages.
	 * 
	 * @param n
	 *            the n
	 */
	void jjtreeOpenNodeScope(Node n) {
		Token t = getToken(1);
		if (t != null) {
			((SimpleNode) n).setLineNumber(t.beginLine);
		}
	}

	/**
	 * Dummy routine, required because NODE_SCOPE_HOOK is true.
	 * 
	 * @param n
	 *            the n
	 */
	void jjtreeCloseNodeScope(Node n) {
	}

	/**
	 * Literal.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void Literal() throws ParseException {
		/* @bgen(jjtree) Literal */
		ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case DECIMAL_LITERAL:
				t = jj_consume_token(DECIMAL_LITERAL);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setDecimalValue(t.image);
				break;
			case OCTAL_LITERAL:
				t = jj_consume_token(OCTAL_LITERAL);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setOctalValue(t.image);
				break;
			case HEX_LITERAL:
				t = jj_consume_token(HEX_LITERAL);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setHexValue(t.image);
				break;
			case FLOATING_POINT_LITERAL:
				t = jj_consume_token(FLOATING_POINT_LITERAL);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setFloatingPointValue(t.image);
				break;
			case STRING_LITERAL:
				t = jj_consume_token(STRING_LITERAL);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setStringValue(t.image.substring(1,
						t.image.length() - 1));
				break;
			case TRUE:
				t = jj_consume_token(TRUE);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setBooleanValue(true);
				break;
			case FALSE:
				t = jj_consume_token(FALSE);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setBooleanValue(false);
				break;
			case NULL:
				t = jj_consume_token(NULL);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				jjtn000.setNullValue();
				break;
			case UNTERMINATED_STRING_LITERAL:
				t = jj_consume_token(UNTERMINATED_STRING_LITERAL);
				jjtree.closeNodeScope(jjtn000, true);
				jjtc000 = false;
				jjtreeCloseNodeScope(jjtn000);
				{
					if (true)
						throw generateParseException();
				}
				break;
			default:
				jj_la1[0] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Identifier.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void Identifier() throws ParseException {
		/* @bgen(jjtree) Identifier */
		ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			t = jj_consume_token(IDENTIFIER);
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setName(t.image);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/*---------------------------------------------*
	 * THE ECMASCRIPT LANGUAGE GRAMMAR STARTS HERE *
	 *---------------------------------------------*/

	/*
	 * Expression syntax follows - 11.1, 11.2
	 */
	/**
	 * Primary expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void PrimaryExpression() throws ParseException {
		switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
		case THIS:
			ASTCompositeReference jjtn002 = new ASTCompositeReference(
					JJTCOMPOSITEREFERENCE);
			boolean jjtc002 = true;
			jjtree.openNodeScope(jjtn002);
			jjtreeOpenNodeScope(jjtn002);
			try {
				ASTThisReference jjtn001 = new ASTThisReference(
						JJTTHISREFERENCE);
				boolean jjtc001 = true;
				jjtree.openNodeScope(jjtn001);
				jjtreeOpenNodeScope(jjtn001);
				try {
					jj_consume_token(THIS);
				} finally {
					if (jjtc001) {
						jjtree.closeNodeScope(jjtn001, true);
						jjtreeCloseNodeScope(jjtn001);
					}
				}
				label_1: while (true) {
					switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
					case LPAREN:
					case LBRACKET:
					case DOT:
						;
						break;
					default:
						jj_la1[1] = jj_gen;
						break label_1;
					}
					PrimarySuffix();
				}
			} catch (Throwable jjte002) {
				if (jjtc002) {
					jjtree.clearNodeScope(jjtn002);
					jjtc002 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte002 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte002;
					}
				}
				if (jjte002 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte002;
					}
				}
				{
					if (true)
						throw (Error) jjte002;
				}
			} finally {
				if (jjtc002) {
					jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
					jjtreeCloseNodeScope(jjtn002);
				}
			}
			break;
		case IDENTIFIER:
			ASTCompositeReference jjtn003 = new ASTCompositeReference(
					JJTCOMPOSITEREFERENCE);
			boolean jjtc003 = true;
			jjtree.openNodeScope(jjtn003);
			jjtreeOpenNodeScope(jjtn003);
			try {
				Identifier();
				label_2: while (true) {
					switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
					case LPAREN:
					case LBRACKET:
					case DOT:
						;
						break;
					default:
						jj_la1[2] = jj_gen;
						break label_2;
					}
					PrimarySuffix();
				}
			} catch (Throwable jjte003) {
				if (jjtc003) {
					jjtree.clearNodeScope(jjtn003);
					jjtc003 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte003 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte003;
					}
				}
				if (jjte003 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte003;
					}
				}
				{
					if (true)
						throw (Error) jjte003;
				}
			} finally {
				if (jjtc003) {
					jjtree.closeNodeScope(jjtn003, jjtree.nodeArity() > 1);
					jjtreeCloseNodeScope(jjtn003);
				}
			}
			break;
		case TRUE:
		case FALSE:
		case NULL:
		case DECIMAL_LITERAL:
		case HEX_LITERAL:
		case OCTAL_LITERAL:
		case FLOATING_POINT_LITERAL:
		case STRING_LITERAL:
		case UNTERMINATED_STRING_LITERAL:
			Literal();
			break;
		case LPAREN:
			ASTCompositeReference jjtn004 = new ASTCompositeReference(
					JJTCOMPOSITEREFERENCE);
			boolean jjtc004 = true;
			jjtree.openNodeScope(jjtn004);
			jjtreeOpenNodeScope(jjtn004);
			try {
				jj_consume_token(LPAREN);
				Expression();
				jj_consume_token(RPAREN);
				label_3: while (true) {
					switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
					case LPAREN:
					case LBRACKET:
					case DOT:
						;
						break;
					default:
						jj_la1[3] = jj_gen;
						break label_3;
					}
					PrimarySuffix();
				}
			} catch (Throwable jjte004) {
				if (jjtc004) {
					jjtree.clearNodeScope(jjtn004);
					jjtc004 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte004 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte004;
					}
				}
				if (jjte004 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte004;
					}
				}
				{
					if (true)
						throw (Error) jjte004;
				}
			} finally {
				if (jjtc004) {
					jjtree.closeNodeScope(jjtn004, jjtree.nodeArity() > 1);
					jjtreeCloseNodeScope(jjtn004);
				}
			}
			break;
		case NEW:
			AllocationExpression();
			break;
		default:
			jj_la1[4] = jj_gen;
			jj_consume_token(-1);
			throw new ParseException();
		}
	}

	/**
	 * Primary suffix.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void PrimarySuffix() throws ParseException {
		switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
		case LPAREN:
			ASTFunctionCallParameters jjtn001 = new ASTFunctionCallParameters(
					JJTFUNCTIONCALLPARAMETERS);
			boolean jjtc001 = true;
			jjtree.openNodeScope(jjtn001);
			jjtreeOpenNodeScope(jjtn001);
			try {
				Arguments();
			} catch (Throwable jjte001) {
				if (jjtc001) {
					jjtree.clearNodeScope(jjtn001);
					jjtc001 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte001 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte001;
					}
				}
				if (jjte001 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte001;
					}
				}
				{
					if (true)
						throw (Error) jjte001;
				}
			} finally {
				if (jjtc001) {
					jjtree.closeNodeScope(jjtn001, true);
					jjtreeCloseNodeScope(jjtn001);
				}
			}
			break;
		case LBRACKET:
			ASTPropertyValueReference jjtn002 = new ASTPropertyValueReference(
					JJTPROPERTYVALUEREFERENCE);
			boolean jjtc002 = true;
			jjtree.openNodeScope(jjtn002);
			jjtreeOpenNodeScope(jjtn002);
			try {
				jj_consume_token(LBRACKET);
				Expression();
				jj_consume_token(RBRACKET);
			} catch (Throwable jjte002) {
				if (jjtc002) {
					jjtree.clearNodeScope(jjtn002);
					jjtc002 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte002 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte002;
					}
				}
				if (jjte002 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte002;
					}
				}
				{
					if (true)
						throw (Error) jjte002;
				}
			} finally {
				if (jjtc002) {
					jjtree.closeNodeScope(jjtn002, true);
					jjtreeCloseNodeScope(jjtn002);
				}
			}
			break;
		case DOT:
			ASTPropertyIdentifierReference jjtn003 = new ASTPropertyIdentifierReference(
					JJTPROPERTYIDENTIFIERREFERENCE);
			boolean jjtc003 = true;
			jjtree.openNodeScope(jjtn003);
			jjtreeOpenNodeScope(jjtn003);
			try {
				jj_consume_token(DOT);
				Identifier();
			} catch (Throwable jjte003) {
				if (jjtc003) {
					jjtree.clearNodeScope(jjtn003);
					jjtc003 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte003 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte003;
					}
				}
				if (jjte003 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte003;
					}
				}
				{
					if (true)
						throw (Error) jjte003;
				}
			} finally {
				if (jjtc003) {
					jjtree.closeNodeScope(jjtn003, true);
					jjtreeCloseNodeScope(jjtn003);
				}
			}
			break;
		default:
			jj_la1[5] = jj_gen;
			jj_consume_token(-1);
			throw new ParseException();
		}
	}

	/**
	 * Arguments.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void Arguments() throws ParseException {
		jj_consume_token(LPAREN);
		switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
		case DELETE:
		case NEW:
		case THIS:
		case TYPEOF:
		case VOID:
		case TRUE:
		case FALSE:
		case NULL:
		case DECIMAL_LITERAL:
		case HEX_LITERAL:
		case OCTAL_LITERAL:
		case FLOATING_POINT_LITERAL:
		case STRING_LITERAL:
		case UNTERMINATED_STRING_LITERAL:
		case IDENTIFIER:
		case LPAREN:
		case BANG:
		case TILDE:
		case INCR:
		case DECR:
		case PLUS:
		case MINUS:
			ArgumentList();
			break;
		default:
			jj_la1[6] = jj_gen;
			;
		}
		jj_consume_token(RPAREN);
	}

	/**
	 * Argument list.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ArgumentList() throws ParseException {
		AssignmentExpression();
		label_4: while (true) {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case COMMA:
				;
				break;
			default:
				jj_la1[7] = jj_gen;
				break label_4;
			}
			jj_consume_token(COMMA);
			AssignmentExpression();
		}
	}

	// ISSUE - New is more flexible, see SYNTAX
	/**
	 * New suffix.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void NewSuffix() throws ParseException {
		ASTPropertyIdentifierReference jjtn001 = new ASTPropertyIdentifierReference(
				JJTPROPERTYIDENTIFIERREFERENCE);
		boolean jjtc001 = true;
		jjtree.openNodeScope(jjtn001);
		jjtreeOpenNodeScope(jjtn001);
		try {
			jj_consume_token(DOT);
			Identifier();
		} catch (Throwable jjte001) {
			if (jjtc001) {
				jjtree.clearNodeScope(jjtn001);
				jjtc001 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte001 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte001;
				}
			}
			if (jjte001 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte001;
				}
			}
			{
				if (true)
					throw (Error) jjte001;
			}
		} finally {
			if (jjtc001) {
				jjtree.closeNodeScope(jjtn001, true);
				jjtreeCloseNodeScope(jjtn001);
			}
		}
	}

	/**
	 * Allocation expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void AllocationExpression() throws ParseException {
		/* @bgen(jjtree) AllocationExpression */
		ASTAllocationExpression jjtn000 = new ASTAllocationExpression(
				JJTALLOCATIONEXPRESSION);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			if (jj_2_1(2)) {
				jj_consume_token(NEW);
				ASTCompositeReference jjtn002 = new ASTCompositeReference(
						JJTCOMPOSITEREFERENCE);
				boolean jjtc002 = true;
				jjtree.openNodeScope(jjtn002);
				jjtreeOpenNodeScope(jjtn002);
				try {
					ASTThisReference jjtn001 = new ASTThisReference(
							JJTTHISREFERENCE);
					boolean jjtc001 = true;
					jjtree.openNodeScope(jjtn001);
					jjtreeOpenNodeScope(jjtn001);
					try {
						jj_consume_token(THIS);
					} finally {
						if (jjtc001) {
							jjtree.closeNodeScope(jjtn001, true);
							jjtreeCloseNodeScope(jjtn001);
						}
					}
					label_5: while (true) {
						switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
						case DOT:
							;
							break;
						default:
							jj_la1[8] = jj_gen;
							break label_5;
						}
						NewSuffix();
					}
				} catch (Throwable jjte002) {
					if (jjtc002) {
						jjtree.clearNodeScope(jjtn002);
						jjtc002 = false;
					} else {
						jjtree.popNode();
					}
					if (jjte002 instanceof RuntimeException) {
						{
							if (true)
								throw (RuntimeException) jjte002;
						}
					}
					if (jjte002 instanceof ParseException) {
						{
							if (true)
								throw (ParseException) jjte002;
						}
					}
					{
						if (true)
							throw (Error) jjte002;
					}
				} finally {
					if (jjtc002) {
						jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
						jjtreeCloseNodeScope(jjtn002);
					}
				}
				ASTFunctionCallParameters jjtn003 = new ASTFunctionCallParameters(
						JJTFUNCTIONCALLPARAMETERS);
				boolean jjtc003 = true;
				jjtree.openNodeScope(jjtn003);
				jjtreeOpenNodeScope(jjtn003);
				try {
					switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
					case LPAREN:
						Arguments();
						break;
					default:
						jj_la1[9] = jj_gen;
						;
					}
				} catch (Throwable jjte003) {
					if (jjtc003) {
						jjtree.clearNodeScope(jjtn003);
						jjtc003 = false;
					} else {
						jjtree.popNode();
					}
					if (jjte003 instanceof RuntimeException) {
						{
							if (true)
								throw (RuntimeException) jjte003;
						}
					}
					if (jjte003 instanceof ParseException) {
						{
							if (true)
								throw (ParseException) jjte003;
						}
					}
					{
						if (true)
							throw (Error) jjte003;
					}
				} finally {
					if (jjtc003) {
						jjtree.closeNodeScope(jjtn003, true);
						jjtreeCloseNodeScope(jjtn003);
					}
				}
			} else {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case NEW:
					jj_consume_token(NEW);
					ASTCompositeReference jjtn004 = new ASTCompositeReference(
							JJTCOMPOSITEREFERENCE);
					boolean jjtc004 = true;
					jjtree.openNodeScope(jjtn004);
					jjtreeOpenNodeScope(jjtn004);
					try {
						Identifier();
						label_6: while (true) {
							switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
							case DOT:
								;
								break;
							default:
								jj_la1[10] = jj_gen;
								break label_6;
							}
							NewSuffix();
						}
					} catch (Throwable jjte004) {
						if (jjtc004) {
							jjtree.clearNodeScope(jjtn004);
							jjtc004 = false;
						} else {
							jjtree.popNode();
						}
						if (jjte004 instanceof RuntimeException) {
							{
								if (true)
									throw (RuntimeException) jjte004;
							}
						}
						if (jjte004 instanceof ParseException) {
							{
								if (true)
									throw (ParseException) jjte004;
							}
						}
						{
							if (true)
								throw (Error) jjte004;
						}
					} finally {
						if (jjtc004) {
							jjtree.closeNodeScope(jjtn004,
									jjtree.nodeArity() > 1);
							jjtreeCloseNodeScope(jjtn004);
						}
					}
					ASTFunctionCallParameters jjtn005 = new ASTFunctionCallParameters(
							JJTFUNCTIONCALLPARAMETERS);
					boolean jjtc005 = true;
					jjtree.openNodeScope(jjtn005);
					jjtreeOpenNodeScope(jjtn005);
					try {
						switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
						case LPAREN:
							Arguments();
							break;
						default:
							jj_la1[11] = jj_gen;
							;
						}
					} catch (Throwable jjte005) {
						if (jjtc005) {
							jjtree.clearNodeScope(jjtn005);
							jjtc005 = false;
						} else {
							jjtree.popNode();
						}
						if (jjte005 instanceof RuntimeException) {
							{
								if (true)
									throw (RuntimeException) jjte005;
							}
						}
						if (jjte005 instanceof ParseException) {
							{
								if (true)
									throw (ParseException) jjte005;
							}
						}
						{
							if (true)
								throw (Error) jjte005;
						}
					} finally {
						if (jjtc005) {
							jjtree.closeNodeScope(jjtn005, true);
							jjtreeCloseNodeScope(jjtn005);
						}
					}
					break;
				default:
					jj_la1[12] = jj_gen;
					jj_consume_token(-1);
					throw new ParseException();
				}
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	// Expressions - 11.3 -11.13
	/**
	 * Postfix op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void PostfixOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case INCR:
				jj_consume_token(INCR);
				break;
			case DECR:
				jj_consume_token(DECR);
				break;
			default:
				jj_la1[13] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Postfix expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void PostfixExpression() throws ParseException {
		/* @bgen(jjtree) #PostfixExpression(> 1) */
		ASTPostfixExpression jjtn000 = new ASTPostfixExpression(
				JJTPOSTFIXEXPRESSION);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			PrimaryExpression();
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case INCR:
			case DECR:
				PostfixOp();
				break;
			default:
				jj_la1[14] = jj_gen;
				;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Unary op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void UnaryOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case DELETE:
				jj_consume_token(DELETE);
				break;
			case VOID:
				jj_consume_token(VOID);
				break;
			case TYPEOF:
				jj_consume_token(TYPEOF);
				break;
			case INCR:
				jj_consume_token(INCR);
				break;
			case DECR:
				jj_consume_token(DECR);
				break;
			case PLUS:
				jj_consume_token(PLUS);
				break;
			case MINUS:
				jj_consume_token(MINUS);
				break;
			case TILDE:
				jj_consume_token(TILDE);
				break;
			case BANG:
				jj_consume_token(BANG);
				break;
			default:
				jj_la1[15] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Unary expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void UnaryExpression() throws ParseException {
		/* @bgen(jjtree) #UnaryExpression(> 1) */
		ASTUnaryExpression jjtn000 = new ASTUnaryExpression(JJTUNARYEXPRESSION);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case NEW:
			case THIS:
			case TRUE:
			case FALSE:
			case NULL:
			case DECIMAL_LITERAL:
			case HEX_LITERAL:
			case OCTAL_LITERAL:
			case FLOATING_POINT_LITERAL:
			case STRING_LITERAL:
			case UNTERMINATED_STRING_LITERAL:
			case IDENTIFIER:
			case LPAREN:
				PostfixExpression();
				break;
			case DELETE:
			case TYPEOF:
			case VOID:
			case BANG:
			case TILDE:
			case INCR:
			case DECR:
			case PLUS:
			case MINUS:
				UnaryOp();
				UnaryExpression();
				break;
			default:
				jj_la1[16] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Mul op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void MulOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case STAR:
				jj_consume_token(STAR);
				break;
			case SLASH:
				jj_consume_token(SLASH);
				break;
			case REM:
				jj_consume_token(REM);
				break;
			default:
				jj_la1[17] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Multiplicative expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void MultiplicativeExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			UnaryExpression();
			label_7: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case STAR:
				case SLASH:
				case REM:
					;
					break;
				default:
					jj_la1[18] = jj_gen;
					break label_7;
				}
				MulOp();
				UnaryExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Adds the op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void AddOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case PLUS:
				jj_consume_token(PLUS);
				break;
			case MINUS:
				jj_consume_token(MINUS);
				break;
			default:
				jj_la1[19] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Additive expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void AdditiveExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			MultiplicativeExpression();
			label_8: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case PLUS:
				case MINUS:
					;
					break;
				default:
					jj_la1[20] = jj_gen;
					break label_8;
				}
				AddOp();
				MultiplicativeExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Shift op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ShiftOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case LSHIFT:
				jj_consume_token(LSHIFT);
				break;
			case RSIGNEDSHIFT:
				jj_consume_token(RSIGNEDSHIFT);
				break;
			case RUNSIGNEDSHIFT:
				jj_consume_token(RUNSIGNEDSHIFT);
				break;
			default:
				jj_la1[21] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Shift expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ShiftExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			AdditiveExpression();
			label_9: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case LSHIFT:
				case RSIGNEDSHIFT:
				case RUNSIGNEDSHIFT:
					;
					break;
				default:
					jj_la1[22] = jj_gen;
					break label_9;
				}
				ShiftOp();
				AdditiveExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Rel op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void RelOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case LT:
				jj_consume_token(LT);
				break;
			case GT:
				jj_consume_token(GT);
				break;
			case LE:
				jj_consume_token(LE);
				break;
			case GE:
				jj_consume_token(GE);
				break;
			default:
				jj_la1[23] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Relational expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void RelationalExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			ShiftExpression();
			label_10: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case GT:
				case LT:
				case LE:
				case GE:
					;
					break;
				default:
					jj_la1[24] = jj_gen;
					break label_10;
				}
				RelOp();
				ShiftExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Equal op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void EqualOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case EQ:
				jj_consume_token(EQ);
				break;
			case NE:
				jj_consume_token(NE);
				break;
			default:
				jj_la1[25] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Equality expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void EqualityExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			RelationalExpression();
			label_11: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case EQ:
				case NE:
					;
					break;
				default:
					jj_la1[26] = jj_gen;
					break label_11;
				}
				EqualOp();
				RelationalExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Bitwise and op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void BitwiseANDOp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			jj_consume_token(BIT_AND);
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Bitwise and expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void BitwiseANDExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			EqualityExpression();
			label_12: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case BIT_AND:
					;
					break;
				default:
					jj_la1[27] = jj_gen;
					break label_12;
				}
				BitwiseANDOp();
				EqualityExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Bitwise xor op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void BitwiseXOROp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			jj_consume_token(XOR);
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Bitwise xor expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void BitwiseXORExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			BitwiseANDExpression();
			label_13: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case XOR:
					;
					break;
				default:
					jj_la1[28] = jj_gen;
					break label_13;
				}
				BitwiseXOROp();
				BitwiseANDExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Bitwise or op.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void BitwiseOROp() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			jj_consume_token(BIT_OR);
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Bitwise or expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void BitwiseORExpression() throws ParseException {
		/* @bgen(jjtree) #BinaryExpressionSequence(> 1) */
		ASTBinaryExpressionSequence jjtn000 = new ASTBinaryExpressionSequence(
				JJTBINARYEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			BitwiseXORExpression();
			label_14: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case BIT_OR:
					;
					break;
				default:
					jj_la1[29] = jj_gen;
					break label_14;
				}
				BitwiseOROp();
				BitwiseXORExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Logical and expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void LogicalANDExpression() throws ParseException {
		/* @bgen(jjtree) #AndExpressionSequence(> 1) */
		ASTAndExpressionSequence jjtn000 = new ASTAndExpressionSequence(
				JJTANDEXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			BitwiseORExpression();
			label_15: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case SC_AND:
					;
					break;
				default:
					jj_la1[30] = jj_gen;
					break label_15;
				}
				jj_consume_token(SC_AND);
				BitwiseORExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Logical or expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void LogicalORExpression() throws ParseException {
		/* @bgen(jjtree) #OrExpressionSequence(> 1) */
		ASTOrExpressionSequence jjtn000 = new ASTOrExpressionSequence(
				JJTOREXPRESSIONSEQUENCE);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			LogicalANDExpression();
			label_16: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case SC_OR:
					;
					break;
				default:
					jj_la1[31] = jj_gen;
					break label_16;
				}
				jj_consume_token(SC_OR);
				LogicalANDExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Conditional expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ConditionalExpression() throws ParseException {
		/* @bgen(jjtree) #ConditionalExpression(> 1) */
		ASTConditionalExpression jjtn000 = new ASTConditionalExpression(
				JJTCONDITIONALEXPRESSION);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			LogicalORExpression();
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case HOOK:
				jj_consume_token(HOOK);
				Expression();
				jj_consume_token(COLON);
				ConditionalExpression();
				break;
			default:
				jj_la1[32] = jj_gen;
				;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	// Must check that ConditionalExpression is an LVALUE if assignement used
	// Maybe in runtime ?
	/**
	 * Assignement operator.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void AssignementOperator() throws ParseException {
		/* @bgen(jjtree) Operator */
		ASTOperator jjtn000 = new ASTOperator(JJTOPERATOR);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case ASSIGN:
				jj_consume_token(ASSIGN);
				break;
			case STARASSIGN:
				jj_consume_token(STARASSIGN);
				break;
			case SLASHASSIGN:
				jj_consume_token(SLASHASSIGN);
				break;
			case REMASSIGN:
				jj_consume_token(REMASSIGN);
				break;
			case PLUSASSIGN:
				jj_consume_token(PLUSASSIGN);
				break;
			case MINUSASSIGN:
				jj_consume_token(MINUSASSIGN);
				break;
			case LSHIFTASSIGN:
				jj_consume_token(LSHIFTASSIGN);
				break;
			case RSIGNEDSHIFTASSIGN:
				jj_consume_token(RSIGNEDSHIFTASSIGN);
				break;
			case RUNSIGNEDSHIFTASSIGN:
				jj_consume_token(RUNSIGNEDSHIFTASSIGN);
				break;
			case ANDASSIGN:
				jj_consume_token(ANDASSIGN);
				break;
			case XORASSIGN:
				jj_consume_token(XORASSIGN);
				break;
			case ORASSIGN:
				jj_consume_token(ORASSIGN);
				break;
			default:
				jj_la1[33] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			jjtn000.setOperator(getToken(0).kind);
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Assignment expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void AssignmentExpression() throws ParseException {
		/* @bgen(jjtree) #AssignmentExpression(> 1) */
		ASTAssignmentExpression jjtn000 = new ASTAssignmentExpression(
				JJTASSIGNMENTEXPRESSION);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			ConditionalExpression();
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case ASSIGN:
			case PLUSASSIGN:
			case MINUSASSIGN:
			case STARASSIGN:
			case SLASHASSIGN:
			case ANDASSIGN:
			case ORASSIGN:
			case XORASSIGN:
			case REMASSIGN:
			case LSHIFTASSIGN:
			case RSIGNEDSHIFTASSIGN:
			case RUNSIGNEDSHIFTASSIGN:
				AssignementOperator();
				AssignmentExpression();
				break;
			default:
				jj_la1[34] = jj_gen;
				;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	// Check that priority is ok, check with assigment
	/**
	 * Expression.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void Expression() throws ParseException {
		/* @bgen(jjtree) #ExpressionList(> 1) */
		ASTExpressionList jjtn000 = new ASTExpressionList(JJTEXPRESSIONLIST);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			AssignmentExpression();
			label_17: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case COMMA:
					;
					break;
				default:
					jj_la1[35] = jj_gen;
					break label_17;
				}
				jj_consume_token(COMMA);
				AssignmentExpression();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/*
	 * Statement syntax - 12
	 */

	/*
	 * Statement declaration syntax follows.
	 */
	/**
	 * Statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void Statement() throws ParseException {
		/* @bgen(jjtree) Statement */
		ASTStatement jjtn000 = new ASTStatement(JJTSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case LBRACE:
				Block();
				break;
			case VAR:
				VariableStatement();
				break;
			case SEMICOLON:
				EmptyStatement();
				break;
			case DELETE:
			case NEW:
			case THIS:
			case TYPEOF:
			case VOID:
			case TRUE:
			case FALSE:
			case NULL:
			case DECIMAL_LITERAL:
			case HEX_LITERAL:
			case OCTAL_LITERAL:
			case FLOATING_POINT_LITERAL:
			case STRING_LITERAL:
			case UNTERMINATED_STRING_LITERAL:
			case IDENTIFIER:
			case LPAREN:
			case BANG:
			case TILDE:
			case INCR:
			case DECR:
			case PLUS:
			case MINUS:
				ExpressionStatement();
				break;
			case IF:
				IfStatement();
				break;
			case FOR:
			case WHILE:
				IterationStatement();
				break;
			case CONTINUE:
				ContinueStatement();
				break;
			case BREAK:
				BreakStatement();
				break;
			case RETURN:
				ReturnStatement();
				break;
			case WITH:
				WithStatement();
				break;
			default:
				jj_la1[36] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Block.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void Block() throws ParseException {
		if (jj_2_2(3)) {
			jj_consume_token(LBRACE);
			ASTStatementList jjtn001 = new ASTStatementList(JJTSTATEMENTLIST);
			boolean jjtc001 = true;
			jjtree.openNodeScope(jjtn001);
			jjtreeOpenNodeScope(jjtn001);
			try {
				jj_consume_token(RBRACE);
			} finally {
				if (jjtc001) {
					jjtree.closeNodeScope(jjtn001, true);
					jjtreeCloseNodeScope(jjtn001);
				}
			}
		} else {
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case LBRACE:
				jj_consume_token(LBRACE);
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case BREAK:
				case CONTINUE:
				case DELETE:
				case FOR:
				case IF:
				case NEW:
				case RETURN:
				case THIS:
				case TYPEOF:
				case VAR:
				case VOID:
				case WHILE:
				case WITH:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case LBRACE:
				case SEMICOLON:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					StatementList();
					break;
				default:
					jj_la1[37] = jj_gen;
					;
				}
				jj_consume_token(RBRACE);
				break;
			default:
				jj_la1[38] = jj_gen;
				jj_consume_token(-1);
				throw new ParseException();
			}
		}
	}

	/**
	 * Variable statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void VariableStatement() throws ParseException {
		jj_consume_token(VAR);
		VariableDeclarationList();
		Sc();
	}

	// Use statement list (instead of void) to group declaration (statement
	// being unary)
	/**
	 * Variable declaration list.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void VariableDeclarationList() throws ParseException {
		/* @bgen(jjtree) #StatementList(> 1) */
		ASTStatementList jjtn000 = new ASTStatementList(JJTSTATEMENTLIST);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			VariableDeclaration();
			label_18: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case COMMA:
					;
					break;
				default:
					jj_la1[39] = jj_gen;
					break label_18;
				}
				jj_consume_token(COMMA);
				VariableDeclaration();
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Variable declaration.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void VariableDeclaration() throws ParseException {
		/* @bgen(jjtree) VariableDeclaration */
		ASTVariableDeclaration jjtn000 = new ASTVariableDeclaration(
				JJTVARIABLEDECLARATION);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			Identifier();
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case ASSIGN:
				Initializer();
				break;
			default:
				jj_la1[40] = jj_gen;
				;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Initializer.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void Initializer() throws ParseException {
		jj_consume_token(ASSIGN);
		AssignmentExpression();
	}

	/**
	 * Empty statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void EmptyStatement() throws ParseException {
		jj_consume_token(SEMICOLON);
	}

	/**
	 * Expression statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ExpressionStatement() throws ParseException {
		Expression();
		Sc();
	}

	/**
	 * Sc.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	void Sc() throws ParseException {
		Token tok = getToken(1);
		if (tok.kind == SEMICOLON) {
			tok = getNextToken();
		} else if (tok.specialToken != null) {
			if ((tok.specialToken.kind != EOL)
					&& (tok.specialToken.kind != SINGLE_LINE_COMMENT)) {
				throw generateParseException();
			}
		} else if ((tok.kind != EOF) && (tok.kind != RBRACE)) {
			throw generateParseException();
		}
	}

	/**
	 * If statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void IfStatement() throws ParseException {
		/* @bgen(jjtree) IfStatement */
		ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(IF);
			jj_consume_token(LPAREN);
			Expression();
			jj_consume_token(RPAREN);
			Statement();
			switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
			case ELSE:
				jj_consume_token(ELSE);
				Statement();
				break;
			default:
				jj_la1[41] = jj_gen;
				;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Iteration statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void IterationStatement() throws ParseException {
		switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
		case WHILE:
			WhileStatement();
			break;
		default:
			jj_la1[42] = jj_gen;
			if (jj_2_3(2147483647)) {
				ForStatement();
			} else if (jj_2_4(2147483647)) {
				ForStatement();
			} else if (jj_2_5(2147483647)) {
				ForVarStatement();
			} else if (jj_2_6(3)) {
				ForInStatement();
			} else if (jj_2_7(3)) {
				ForVarInStatement();
			} else {
				jj_consume_token(-1);
				throw new ParseException();
			}
		}
	}

	/**
	 * While statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void WhileStatement() throws ParseException {
		/* @bgen(jjtree) WhileStatement */
		ASTWhileStatement jjtn000 = new ASTWhileStatement(JJTWHILESTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(WHILE);
			jj_consume_token(LPAREN);
			Expression();
			jj_consume_token(RPAREN);
			Statement();
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * For statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ForStatement() throws ParseException {
		/* @bgen(jjtree) ForStatement */
		ASTForStatement jjtn000 = new ASTForStatement(JJTFORSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(FOR);
			jj_consume_token(LPAREN);
			ASTEmptyExpression jjtn001 = new ASTEmptyExpression(
					JJTEMPTYEXPRESSION);
			boolean jjtc001 = true;
			jjtree.openNodeScope(jjtn001);
			jjtreeOpenNodeScope(jjtn001);
			try {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case DELETE:
				case NEW:
				case THIS:
				case TYPEOF:
				case VOID:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					Expression();
					break;
				default:
					jj_la1[43] = jj_gen;
					;
				}
			} catch (Throwable jjte001) {
				if (jjtc001) {
					jjtree.clearNodeScope(jjtn001);
					jjtc001 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte001 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte001;
					}
				}
				if (jjte001 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte001;
					}
				}
				{
					if (true)
						throw (Error) jjte001;
				}
			} finally {
				if (jjtc001) {
					jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() == 0);
					jjtreeCloseNodeScope(jjtn001);
				}
			}
			jj_consume_token(SEMICOLON);
			ASTEmptyExpression jjtn002 = new ASTEmptyExpression(
					JJTEMPTYEXPRESSION);
			boolean jjtc002 = true;
			jjtree.openNodeScope(jjtn002);
			jjtreeOpenNodeScope(jjtn002);
			try {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case DELETE:
				case NEW:
				case THIS:
				case TYPEOF:
				case VOID:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					Expression();
					break;
				default:
					jj_la1[44] = jj_gen;
					;
				}
			} catch (Throwable jjte002) {
				if (jjtc002) {
					jjtree.clearNodeScope(jjtn002);
					jjtc002 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte002 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte002;
					}
				}
				if (jjte002 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte002;
					}
				}
				{
					if (true)
						throw (Error) jjte002;
				}
			} finally {
				if (jjtc002) {
					jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() == 0);
					jjtreeCloseNodeScope(jjtn002);
				}
			}
			jj_consume_token(SEMICOLON);
			ASTEmptyExpression jjtn003 = new ASTEmptyExpression(
					JJTEMPTYEXPRESSION);
			boolean jjtc003 = true;
			jjtree.openNodeScope(jjtn003);
			jjtreeOpenNodeScope(jjtn003);
			try {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case DELETE:
				case NEW:
				case THIS:
				case TYPEOF:
				case VOID:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					Expression();
					break;
				default:
					jj_la1[45] = jj_gen;
					;
				}
			} catch (Throwable jjte003) {
				if (jjtc003) {
					jjtree.clearNodeScope(jjtn003);
					jjtc003 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte003 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte003;
					}
				}
				if (jjte003 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte003;
					}
				}
				{
					if (true)
						throw (Error) jjte003;
				}
			} finally {
				if (jjtc003) {
					jjtree.closeNodeScope(jjtn003, jjtree.nodeArity() == 0);
					jjtreeCloseNodeScope(jjtn003);
				}
			}
			jj_consume_token(RPAREN);
			Statement();
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * For var statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ForVarStatement() throws ParseException {
		/* @bgen(jjtree) ForVarStatement */
		ASTForVarStatement jjtn000 = new ASTForVarStatement(JJTFORVARSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(FOR);
			jj_consume_token(LPAREN);
			jj_consume_token(VAR);
			VariableDeclarationList();
			jj_consume_token(SEMICOLON);
			ASTEmptyExpression jjtn001 = new ASTEmptyExpression(
					JJTEMPTYEXPRESSION);
			boolean jjtc001 = true;
			jjtree.openNodeScope(jjtn001);
			jjtreeOpenNodeScope(jjtn001);
			try {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case DELETE:
				case NEW:
				case THIS:
				case TYPEOF:
				case VOID:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					Expression();
					break;
				default:
					jj_la1[46] = jj_gen;
					;
				}
			} catch (Throwable jjte001) {
				if (jjtc001) {
					jjtree.clearNodeScope(jjtn001);
					jjtc001 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte001 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte001;
					}
				}
				if (jjte001 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte001;
					}
				}
				{
					if (true)
						throw (Error) jjte001;
				}
			} finally {
				if (jjtc001) {
					jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() == 0);
					jjtreeCloseNodeScope(jjtn001);
				}
			}
			jj_consume_token(SEMICOLON);
			ASTEmptyExpression jjtn002 = new ASTEmptyExpression(
					JJTEMPTYEXPRESSION);
			boolean jjtc002 = true;
			jjtree.openNodeScope(jjtn002);
			jjtreeOpenNodeScope(jjtn002);
			try {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case DELETE:
				case NEW:
				case THIS:
				case TYPEOF:
				case VOID:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					Expression();
					break;
				default:
					jj_la1[47] = jj_gen;
					;
				}
			} catch (Throwable jjte002) {
				if (jjtc002) {
					jjtree.clearNodeScope(jjtn002);
					jjtc002 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte002 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte002;
					}
				}
				if (jjte002 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte002;
					}
				}
				{
					if (true)
						throw (Error) jjte002;
				}
			} finally {
				if (jjtc002) {
					jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() == 0);
					jjtreeCloseNodeScope(jjtn002);
				}
			}
			jj_consume_token(RPAREN);
			Statement();
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * For in statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ForInStatement() throws ParseException {
		/* @bgen(jjtree) ForInStatement */
		ASTForInStatement jjtn000 = new ASTForInStatement(JJTFORINSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(FOR);
			jj_consume_token(LPAREN);
			Expression();
			jj_consume_token(IN);
			Expression();
			jj_consume_token(RPAREN);
			Statement();
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * For var in statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ForVarInStatement() throws ParseException {
		/* @bgen(jjtree) ForVarInStatement */
		ASTForVarInStatement jjtn000 = new ASTForVarInStatement(
				JJTFORVARINSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(FOR);
			jj_consume_token(LPAREN);
			jj_consume_token(VAR);
			Identifier();
			ASTEmptyExpression jjtn001 = new ASTEmptyExpression(
					JJTEMPTYEXPRESSION);
			boolean jjtc001 = true;
			jjtree.openNodeScope(jjtn001);
			jjtreeOpenNodeScope(jjtn001);
			try {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case ASSIGN:
					Initializer();
					break;
				default:
					jj_la1[48] = jj_gen;
					;
				}
			} catch (Throwable jjte001) {
				if (jjtc001) {
					jjtree.clearNodeScope(jjtn001);
					jjtc001 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte001 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte001;
					}
				}
				if (jjte001 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte001;
					}
				}
				{
					if (true)
						throw (Error) jjte001;
				}
			} finally {
				if (jjtc001) {
					jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() == 0);
					jjtreeCloseNodeScope(jjtn001);
				}
			}
			jj_consume_token(IN);
			Expression();
			jj_consume_token(RPAREN);
			Statement();
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Continue statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ContinueStatement() throws ParseException {
		/* @bgen(jjtree) ContinueStatement */
		ASTContinueStatement jjtn000 = new ASTContinueStatement(
				JJTCONTINUESTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(CONTINUE);
			Sc();
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Break statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void BreakStatement() throws ParseException {
		/* @bgen(jjtree) BreakStatement */
		ASTBreakStatement jjtn000 = new ASTBreakStatement(JJTBREAKSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(BREAK);
			Sc();
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Return statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void ReturnStatement() throws ParseException {
		/* @bgen(jjtree) ReturnStatement */
		ASTReturnStatement jjtn000 = new ASTReturnStatement(JJTRETURNSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(RETURN);
			ASTEmptyExpression jjtn001 = new ASTEmptyExpression(
					JJTEMPTYEXPRESSION);
			boolean jjtc001 = true;
			jjtree.openNodeScope(jjtn001);
			jjtreeOpenNodeScope(jjtn001);
			try {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case DELETE:
				case NEW:
				case THIS:
				case TYPEOF:
				case VOID:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					Expression();
					break;
				default:
					jj_la1[49] = jj_gen;
					;
				}
			} catch (Throwable jjte001) {
				if (jjtc001) {
					jjtree.clearNodeScope(jjtn001);
					jjtc001 = false;
				} else {
					jjtree.popNode();
				}
				if (jjte001 instanceof RuntimeException) {
					{
						if (true)
							throw (RuntimeException) jjte001;
					}
				}
				if (jjte001 instanceof ParseException) {
					{
						if (true)
							throw (ParseException) jjte001;
					}
				}
				{
					if (true)
						throw (Error) jjte001;
				}
			} finally {
				if (jjtc001) {
					jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() == 0);
					jjtreeCloseNodeScope(jjtn001);
				}
			}
			Sc();
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * With statement.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void WithStatement() throws ParseException {
		/* @bgen(jjtree) WithStatement */
		ASTWithStatement jjtn000 = new ASTWithStatement(JJTWITHSTATEMENT);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			jj_consume_token(WITH);
			jj_consume_token(LPAREN);
			Expression();
			jj_consume_token(RPAREN);
			Statement();
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/*
	 * Function definition - 13
	 */

	/*
	 * Function declaration syntax follows.
	 */

	// Formal parameters are handled in a somehwat special way
	// as it is an entry point to parse the parameter list
	// of Function.
	/**
	 * Function declaration.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void FunctionDeclaration() throws ParseException {
		/* @bgen(jjtree) FunctionDeclaration */
		ASTFunctionDeclaration jjtn000 = new ASTFunctionDeclaration(
				JJTFUNCTIONDECLARATION);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t1 = getToken(1); // 0 is the last matched token, so use 1 to get
		// the next one.
		Token t2;
		try {
			try {
				jj_consume_token(FUNCTION);
				Identifier();
				ASTFormalParameterList jjtn001 = new ASTFormalParameterList(
						JJTFORMALPARAMETERLIST);
				boolean jjtc001 = true;
				jjtree.openNodeScope(jjtn001);
				jjtreeOpenNodeScope(jjtn001);
				try {
					jj_consume_token(LPAREN);
					switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
					case IDENTIFIER:
						FormalParameterList();
						break;
					default:
						jj_la1[50] = jj_gen;
						;
					}
					jj_consume_token(RPAREN);
				} catch (Throwable jjte001) {
					if (jjtc001) {
						jjtree.clearNodeScope(jjtn001);
						jjtc001 = false;
					} else {
						jjtree.popNode();
					}
					if (jjte001 instanceof RuntimeException) {
						{
							if (true)
								throw (RuntimeException) jjte001;
						}
					}
					if (jjte001 instanceof ParseException) {
						{
							if (true)
								throw (ParseException) jjte001;
						}
					}
					{
						if (true)
							throw (Error) jjte001;
					}
				} finally {
					if (jjtc001) {
						jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() == 0);
						jjtreeCloseNodeScope(jjtn001);
					}
				}
				Block();
			} finally {
				t2 = getToken(0);
				StringBuffer sourceString = new StringBuffer("");

				// test special case for empty production
				if (t2.next != t1) { // Something consumed.

					for (; t1 != t2; t1 = t1.next) {
						if (t1.specialToken != null) {
							sourceString.append(t1.specialToken.image); // last
																		// special
																		// token
						}
						sourceString.append(t1.image);
						sourceString.append(" ");
					}
				}
				sourceString.append(t2.image);
				jjtn000.setSourceString(sourceString.toString());
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
	}

	/**
	 * Formal parameter list.
	 * 
	 * @return the simple node
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public SimpleNode FormalParameterList() throws ParseException {
		/* @bgen(jjtree) FormalParameterList */
		ASTFormalParameterList jjtn000 = new ASTFormalParameterList(
				JJTFORMALPARAMETERLIST);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			Identifier();
			label_19: while (true) {
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case COMMA:
					;
					break;
				default:
					jj_la1[51] = jj_gen;
					break label_19;
				}
				jj_consume_token(COMMA);
				Identifier();
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			{
				if (true)
					return jjtn000;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
		throw new Error("Missing return statement in function");
	}

	/*
	 * Program structuring syntax - 14
	 */

	// ASTProgram Program() #Program :
	/**
	 * Program.
	 * 
	 * @return the simple node
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public SimpleNode Program() throws ParseException {
		/* @bgen(jjtree) Program */
		ASTProgram jjtn000 = new ASTProgram(JJTPROGRAM);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		try {
			label_20: while (true) {
				SourceElement();
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case BREAK:
				case CONTINUE:
				case DELETE:
				case FOR:
				case FUNCTION:
				case IF:
				case NEW:
				case RETURN:
				case THIS:
				case TYPEOF:
				case VAR:
				case VOID:
				case WHILE:
				case WITH:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case LBRACE:
				case SEMICOLON:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					;
					break;
				default:
					jj_la1[52] = jj_gen;
					break label_20;
				}
			}
			jj_consume_token(0);
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			{
				if (true)
					return jjtn000;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
		throw new Error("Missing return statement in function");
	}

	/**
	 * Source element.
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public void SourceElement() throws ParseException {
		switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
		case BREAK:
		case CONTINUE:
		case DELETE:
		case FOR:
		case IF:
		case NEW:
		case RETURN:
		case THIS:
		case TYPEOF:
		case VAR:
		case VOID:
		case WHILE:
		case WITH:
		case TRUE:
		case FALSE:
		case NULL:
		case DECIMAL_LITERAL:
		case HEX_LITERAL:
		case OCTAL_LITERAL:
		case FLOATING_POINT_LITERAL:
		case STRING_LITERAL:
		case UNTERMINATED_STRING_LITERAL:
		case IDENTIFIER:
		case LPAREN:
		case LBRACE:
		case SEMICOLON:
		case BANG:
		case TILDE:
		case INCR:
		case DECR:
		case PLUS:
		case MINUS:
			Statement();
			break;
		case FUNCTION:
			FunctionDeclaration();
			break;
		default:
			jj_la1[53] = jj_gen;
			jj_consume_token(-1);
			throw new ParseException();
		}
	}

	/**
	 * Statement list.
	 * 
	 * @return the simple node
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final public SimpleNode StatementList() throws ParseException {
		/* @bgen(jjtree) StatementList */
		ASTStatementList jjtn000 = new ASTStatementList(JJTSTATEMENTLIST);
		boolean jjtc000 = true;
		jjtree.openNodeScope(jjtn000);
		jjtreeOpenNodeScope(jjtn000);
		Token t;
		try {
			label_21: while (true) {
				Statement();
				switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
				case BREAK:
				case CONTINUE:
				case DELETE:
				case FOR:
				case IF:
				case NEW:
				case RETURN:
				case THIS:
				case TYPEOF:
				case VAR:
				case VOID:
				case WHILE:
				case WITH:
				case TRUE:
				case FALSE:
				case NULL:
				case DECIMAL_LITERAL:
				case HEX_LITERAL:
				case OCTAL_LITERAL:
				case FLOATING_POINT_LITERAL:
				case STRING_LITERAL:
				case UNTERMINATED_STRING_LITERAL:
				case IDENTIFIER:
				case LPAREN:
				case LBRACE:
				case SEMICOLON:
				case BANG:
				case TILDE:
				case INCR:
				case DECR:
				case PLUS:
				case MINUS:
					;
					break;
				default:
					jj_la1[54] = jj_gen;
					break label_21;
				}
			}
			jjtree.closeNodeScope(jjtn000, true);
			jjtc000 = false;
			jjtreeCloseNodeScope(jjtn000);
			{
				if (true)
					return jjtn000;
			}
		} catch (Throwable jjte000) {
			if (jjtc000) {
				jjtree.clearNodeScope(jjtn000);
				jjtc000 = false;
			} else {
				jjtree.popNode();
			}
			if (jjte000 instanceof RuntimeException) {
				{
					if (true)
						throw (RuntimeException) jjte000;
				}
			}
			if (jjte000 instanceof ParseException) {
				{
					if (true)
						throw (ParseException) jjte000;
				}
			}
			{
				if (true)
					throw (Error) jjte000;
			}
		} finally {
			if (jjtc000) {
				jjtree.closeNodeScope(jjtn000, true);
				jjtreeCloseNodeScope(jjtn000);
			}
		}
		throw new Error("Missing return statement in function");
	}

	/**
	 * Jj_2_1.
	 * 
	 * @param xla
	 *            the xla
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_2_1(int xla) {
		jj_la = xla;
		jj_lastpos = jj_scanpos = token;
		try {
			return !jj_3_1();
		} catch (LookaheadSuccess ls) {
			return true;
		} finally {
			jj_save(0, xla);
		}
	}

	/**
	 * Jj_2_2.
	 * 
	 * @param xla
	 *            the xla
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_2_2(int xla) {
		jj_la = xla;
		jj_lastpos = jj_scanpos = token;
		try {
			return !jj_3_2();
		} catch (LookaheadSuccess ls) {
			return true;
		} finally {
			jj_save(1, xla);
		}
	}

	/**
	 * Jj_2_3.
	 * 
	 * @param xla
	 *            the xla
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_2_3(int xla) {
		jj_la = xla;
		jj_lastpos = jj_scanpos = token;
		try {
			return !jj_3_3();
		} catch (LookaheadSuccess ls) {
			return true;
		} finally {
			jj_save(2, xla);
		}
	}

	/**
	 * Jj_2_4.
	 * 
	 * @param xla
	 *            the xla
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_2_4(int xla) {
		jj_la = xla;
		jj_lastpos = jj_scanpos = token;
		try {
			return !jj_3_4();
		} catch (LookaheadSuccess ls) {
			return true;
		} finally {
			jj_save(3, xla);
		}
	}

	/**
	 * Jj_2_5.
	 * 
	 * @param xla
	 *            the xla
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_2_5(int xla) {
		jj_la = xla;
		jj_lastpos = jj_scanpos = token;
		try {
			return !jj_3_5();
		} catch (LookaheadSuccess ls) {
			return true;
		} finally {
			jj_save(4, xla);
		}
	}

	/**
	 * Jj_2_6.
	 * 
	 * @param xla
	 *            the xla
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_2_6(int xla) {
		jj_la = xla;
		jj_lastpos = jj_scanpos = token;
		try {
			return !jj_3_6();
		} catch (LookaheadSuccess ls) {
			return true;
		} finally {
			jj_save(5, xla);
		}
	}

	/**
	 * Jj_2_7.
	 * 
	 * @param xla
	 *            the xla
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_2_7(int xla) {
		jj_la = xla;
		jj_lastpos = jj_scanpos = token;
		try {
			return !jj_3_7();
		} catch (LookaheadSuccess ls) {
			return true;
		} finally {
			jj_save(6, xla);
		}
	}

	/**
	 * Jj_3 r_32.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_32() {
		if (jj_scan_token(IDENTIFIER))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_55.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_55() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(73)) {
			jj_scanpos = xsp;
			if (jj_scan_token(76))
				return true;
		}
		return false;
	}

	/**
	 * Jj_3 r_57.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_57() {
		if (jj_3R_61())
			return true;
		if (jj_3R_56())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_29.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_29() {
		if (jj_scan_token(COMMA))
			return true;
		if (jj_3R_28())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_92.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_92() {
		if (jj_scan_token(UNTERMINATED_STRING_LITERAL))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_50.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_50() {
		if (jj_3R_53())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_54()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_33.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_33() {
		if (jj_3R_37())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_91.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_91() {
		if (jj_scan_token(NULL))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_60.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_60() {
		if (jj_3R_64())
			return true;
		if (jj_3R_59())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_90.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_90() {
		if (jj_scan_token(FALSE))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_37.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_37() {
		if (jj_scan_token(ASSIGN))
			return true;
		if (jj_3R_26())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_89.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_89() {
		if (jj_scan_token(TRUE))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_58.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_58() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(68)) {
			jj_scanpos = xsp;
			if (jj_scan_token(67)) {
				jj_scanpos = xsp;
				if (jj_scan_token(74)) {
					jj_scanpos = xsp;
					if (jj_scan_token(75))
						return true;
				}
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_28.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_28() {
		if (jj_3R_32())
			return true;
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_33())
			jj_scanpos = xsp;
		return false;
	}

	/**
	 * Jj_3 r_53.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_53() {
		if (jj_3R_56())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_57()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_88.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_88() {
		if (jj_scan_token(STRING_LITERAL))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_23.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_23() {
		if (jj_3R_28())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_29()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_87.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_87() {
		if (jj_scan_token(FLOATING_POINT_LITERAL))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_86.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_86() {
		if (jj_scan_token(HEX_LITERAL))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_61.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_61() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(89)) {
			jj_scanpos = xsp;
			if (jj_scan_token(90)) {
				jj_scanpos = xsp;
				if (jj_scan_token(91))
					return true;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_85.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_85() {
		if (jj_scan_token(OCTAL_LITERAL))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_63.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_63() {
		if (jj_3R_67())
			return true;
		if (jj_3R_62())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_56.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_56() {
		if (jj_3R_59())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_60()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_80.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_80() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_84()) {
			jj_scanpos = xsp;
			if (jj_3R_85()) {
				jj_scanpos = xsp;
				if (jj_3R_86()) {
					jj_scanpos = xsp;
					if (jj_3R_87()) {
						jj_scanpos = xsp;
						if (jj_3R_88()) {
							jj_scanpos = xsp;
							if (jj_3R_89()) {
								jj_scanpos = xsp;
								if (jj_3R_90()) {
									jj_scanpos = xsp;
									if (jj_3R_91()) {
										jj_scanpos = xsp;
										if (jj_3R_92())
											return true;
									}
								}
							}
						}
					}
				}
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_84.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_84() {
		if (jj_scan_token(DECIMAL_LITERAL))
			return true;
		return false;
	}

	/**
	 * Jj_3_2.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3_2() {
		if (jj_scan_token(LBRACE))
			return true;
		if (jj_scan_token(RBRACE))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_27.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_27() {
		if (jj_scan_token(COMMA))
			return true;
		if (jj_3R_26())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_64.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_64() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(81)) {
			jj_scanpos = xsp;
			if (jj_scan_token(82))
				return true;
		}
		return false;
	}

	/**
	 * Jj_3 r_59.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_59() {
		if (jj_3R_62())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_63()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_22.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_22() {
		if (jj_3R_26())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_27()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_100.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_100() {
		if (jj_3R_101())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_71.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_71() {
		if (jj_3R_77())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_67.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_67() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(83)) {
			jj_scanpos = xsp;
			if (jj_scan_token(84)) {
				jj_scanpos = xsp;
				if (jj_scan_token(88))
					return true;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_98.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_98() {
		if (jj_3R_101())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_35.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_35() {
		if (jj_scan_token(HOOK))
			return true;
		if (jj_3R_22())
			return true;
		if (jj_scan_token(COLON))
			return true;
		if (jj_3R_30())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_31.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_31() {
		if (jj_3R_36())
			return true;
		if (jj_3R_26())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_66.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_66() {
		if (jj_3R_69())
			return true;
		if (jj_3R_62())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_62.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_62() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_65()) {
			jj_scanpos = xsp;
			if (jj_3R_66())
				return true;
		}
		return false;
	}

	/**
	 * Jj_3 r_65.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_65() {
		if (jj_3R_68())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_26.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_26() {
		if (jj_3R_30())
			return true;
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_31())
			jj_scanpos = xsp;
		return false;
	}

	/**
	 * Jj_3 r_39.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_39() {
		if (jj_scan_token(SC_OR))
			return true;
		if (jj_3R_38())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_41.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_41() {
		if (jj_scan_token(SC_AND))
			return true;
		if (jj_3R_40())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_69.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_69() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(13)) {
			jj_scanpos = xsp;
			if (jj_scan_token(24)) {
				jj_scanpos = xsp;
				if (jj_scan_token(22)) {
					jj_scanpos = xsp;
					if (jj_scan_token(79)) {
						jj_scanpos = xsp;
						if (jj_scan_token(80)) {
							jj_scanpos = xsp;
							if (jj_scan_token(81)) {
								jj_scanpos = xsp;
								if (jj_scan_token(82)) {
									jj_scanpos = xsp;
									if (jj_scan_token(70)) {
										jj_scanpos = xsp;
										if (jj_scan_token(69))
											return true;
									}
								}
							}
						}
					}
				}
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_36.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_36() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(66)) {
			jj_scanpos = xsp;
			if (jj_scan_token(94)) {
				jj_scanpos = xsp;
				if (jj_scan_token(95)) {
					jj_scanpos = xsp;
					if (jj_scan_token(99)) {
						jj_scanpos = xsp;
						if (jj_scan_token(92)) {
							jj_scanpos = xsp;
							if (jj_scan_token(93)) {
								jj_scanpos = xsp;
								if (jj_scan_token(100)) {
									jj_scanpos = xsp;
									if (jj_scan_token(101)) {
										jj_scanpos = xsp;
										if (jj_scan_token(102)) {
											jj_scanpos = xsp;
											if (jj_scan_token(96)) {
												jj_scanpos = xsp;
												if (jj_scan_token(98)) {
													jj_scanpos = xsp;
													if (jj_scan_token(97))
														return true;
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_99.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_99() {
		if (jj_3R_102())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_68.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_68() {
		if (jj_3R_70())
			return true;
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_71())
			jj_scanpos = xsp;
		return false;
	}

	/**
	 * Jj_3 r_97.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_97() {
		if (jj_3R_102())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_43.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_43() {
		if (jj_3R_46())
			return true;
		if (jj_3R_42())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_30.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_30() {
		if (jj_3R_34())
			return true;
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_35())
			jj_scanpos = xsp;
		return false;
	}

	/**
	 * Jj_3 r_34.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_34() {
		if (jj_3R_38())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_39()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_105.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_105() {
		if (jj_scan_token(COMMA))
			return true;
		if (jj_3R_26())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_77.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_77() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_scan_token(79)) {
			jj_scanpos = xsp;
			if (jj_scan_token(80))
				return true;
		}
		return false;
	}

	/**
	 * Jj_3 r_38.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_38() {
		if (jj_3R_40())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_41()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_45.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_45() {
		if (jj_3R_49())
			return true;
		if (jj_3R_44())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_25.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_25() {
		if (jj_scan_token(FOR))
			return true;
		if (jj_scan_token(LPAREN))
			return true;
		if (jj_scan_token(VAR))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_93.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_93() {
		if (jj_scan_token(NEW))
			return true;
		if (jj_3R_32())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_99()) {
				jj_scanpos = xsp;
				break;
			}
		}
		xsp = jj_scanpos;
		if (jj_3R_100())
			jj_scanpos = xsp;
		return false;
	}

	/**
	 * Jj_3_1.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3_1() {
		if (jj_scan_token(NEW))
			return true;
		if (jj_scan_token(THIS))
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_97()) {
				jj_scanpos = xsp;
				break;
			}
		}
		xsp = jj_scanpos;
		if (jj_3R_98())
			jj_scanpos = xsp;
		return false;
	}

	/**
	 * Jj_3 r_40.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_40() {
		if (jj_3R_42())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_43()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_82.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_82() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3_1()) {
			jj_scanpos = xsp;
			if (jj_3R_93())
				return true;
		}
		return false;
	}

	/**
	 * Jj_3 r_24.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_24() {
		if (jj_scan_token(FOR))
			return true;
		if (jj_scan_token(LPAREN))
			return true;
		if (jj_3R_22())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_81.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_81() {
		if (jj_3R_83())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_102.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_102() {
		if (jj_scan_token(DOT))
			return true;
		if (jj_3R_32())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_104.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_104() {
		if (jj_3R_26())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_105()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_103.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_103() {
		if (jj_3R_104())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_48.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_48() {
		if (jj_3R_52())
			return true;
		if (jj_3R_47())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_46.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_46() {
		if (jj_scan_token(BIT_OR))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_101.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_101() {
		if (jj_scan_token(LPAREN))
			return true;
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_103())
			jj_scanpos = xsp;
		if (jj_scan_token(RPAREN))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_78.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_78() {
		if (jj_3R_83())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_42.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_42() {
		if (jj_3R_44())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_45()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_79.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_79() {
		if (jj_3R_83())
			return true;
		return false;
	}

	/**
	 * Jj_3_5.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3_5() {
		if (jj_scan_token(FOR))
			return true;
		if (jj_scan_token(LPAREN))
			return true;
		if (jj_scan_token(VAR))
			return true;
		if (jj_3R_23())
			return true;
		if (jj_scan_token(SEMICOLON))
			return true;
		return false;
	}

	/**
	 * Jj_3_4.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3_4() {
		if (jj_scan_token(FOR))
			return true;
		if (jj_scan_token(LPAREN))
			return true;
		if (jj_scan_token(SEMICOLON))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_96.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_96() {
		if (jj_scan_token(DOT))
			return true;
		if (jj_3R_32())
			return true;
		return false;
	}

	/**
	 * Jj_3_3.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3_3() {
		if (jj_scan_token(FOR))
			return true;
		if (jj_scan_token(LPAREN))
			return true;
		if (jj_3R_22())
			return true;
		if (jj_scan_token(SEMICOLON))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_95.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_95() {
		if (jj_scan_token(LBRACKET))
			return true;
		if (jj_3R_22())
			return true;
		if (jj_scan_token(RBRACKET))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_94.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_94() {
		if (jj_3R_101())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_83.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_83() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_94()) {
			jj_scanpos = xsp;
			if (jj_3R_95()) {
				jj_scanpos = xsp;
				if (jj_3R_96())
					return true;
			}
		}
		return false;
	}

	/**
	 * Jj_3_7.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3_7() {
		if (jj_3R_25())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_51.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_51() {
		if (jj_3R_55())
			return true;
		if (jj_3R_50())
			return true;
		return false;
	}

	/**
	 * Jj_3_6.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3_6() {
		if (jj_3R_24())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_76.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_76() {
		if (jj_3R_82())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_49.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_49() {
		if (jj_scan_token(XOR))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_75.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_75() {
		if (jj_scan_token(LPAREN))
			return true;
		if (jj_3R_22())
			return true;
		if (jj_scan_token(RPAREN))
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_81()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_74.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_74() {
		if (jj_3R_80())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_70.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_70() {
		Token xsp;
		xsp = jj_scanpos;
		if (jj_3R_72()) {
			jj_scanpos = xsp;
			if (jj_3R_73()) {
				jj_scanpos = xsp;
				if (jj_3R_74()) {
					jj_scanpos = xsp;
					if (jj_3R_75()) {
						jj_scanpos = xsp;
						if (jj_3R_76())
							return true;
					}
				}
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_72.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_72() {
		if (jj_scan_token(THIS))
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_78()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_44.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_44() {
		if (jj_3R_47())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_48()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_73.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_73() {
		if (jj_3R_32())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_79()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/**
	 * Jj_3 r_52.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_52() {
		if (jj_scan_token(BIT_AND))
			return true;
		return false;
	}

	/**
	 * Jj_3 r_54.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_54() {
		if (jj_3R_58())
			return true;
		if (jj_3R_53())
			return true;
		return false;
	}

	/**
	 * Jj_3 r_47.
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_3R_47() {
		if (jj_3R_50())
			return true;
		Token xsp;
		while (true) {
			xsp = jj_scanpos;
			if (jj_3R_51()) {
				jj_scanpos = xsp;
				break;
			}
		}
		return false;
	}

	/** The token_source. */
	public EcmaScriptTokenManager token_source;

	/** The jj_input_stream. */
	SimpleCharStream jj_input_stream;

	/** The jj_nt. */
	public Token token, jj_nt;

	/** The jj_ntk. */
	private int jj_ntk;

	/** The jj_lastpos. */
	private Token jj_scanpos, jj_lastpos;

	/** The jj_la. */
	private int jj_la;

	/** The looking ahead. */
	public boolean lookingAhead = false;

	/** The jj_sem la. */
	private boolean jj_semLA;

	/** The jj_gen. */
	private int jj_gen;

	/** The jj_la1. */
	final private int[] jj_la1 = new int[55];

	/** The jj_la1_0. */
	static private int[] jj_la1_0;

	/** The jj_la1_1. */
	static private int[] jj_la1_1;

	/** The jj_la1_2. */
	static private int[] jj_la1_2;

	/** The jj_la1_3. */
	static private int[] jj_la1_3;
	static {
		jj_la1_0();
		jj_la1_1();
		jj_la1_2();
		jj_la1_3();
	}

	/**
	 * Jj_la1_0.
	 */
	private static void jj_la1_0() {
		jj_la1_0 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x280000, 0x0, 0x1682000,
				0x0, 0x0, 0x0, 0x0, 0x0, 0x80000, 0x0, 0x0, 0x1402000,
				0x1682000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
				0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7fab800,
				0x7fab800, 0x0, 0x0, 0x0, 0x4000, 0x2000000, 0x1682000,
				0x1682000, 0x1682000, 0x1682000, 0x1682000, 0x0, 0x1682000,
				0x0, 0x0, 0x7fbb800, 0x7fbb800, 0x7fab800, };
	}

	/**
	 * Jj_la1_1.
	 */
	private static void jj_la1_1() {
		jj_la1_1 = new int[] { 0x2bf800, 0x22000000, 0x22000000, 0x22000000,
				0x26bf800, 0x22000000, 0x26bf800, 0x0, 0x0, 0x2000000, 0x0,
				0x2000000, 0x0, 0x0, 0x0, 0x0, 0x26bf800, 0x0, 0x0, 0x0, 0x0,
				0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
				0x0, 0x0, 0x0, 0x8a6bf800, 0x8a6bf800, 0x8000000, 0x0, 0x0,
				0x0, 0x0, 0x26bf800, 0x26bf800, 0x26bf800, 0x26bf800,
				0x26bf800, 0x0, 0x26bf800, 0x400000, 0x0, 0x8a6bf800,
				0x8a6bf800, 0x8a6bf800, };
	}

	/**
	 * Jj_la1_2.
	 */
	private static void jj_la1_2() {
		jj_la1_2 = new int[] { 0x0, 0x2, 0x2, 0x2, 0x0, 0x2, 0x78060, 0x1, 0x2,
				0x0, 0x2, 0x0, 0x0, 0x18000, 0x18000, 0x78060, 0x78060,
				0x1180000, 0x1180000, 0x60000, 0x60000, 0xe000000, 0xe000000,
				0xc18, 0xc18, 0x1200, 0x1200, 0x200000, 0x800000, 0x400000,
				0x4000, 0x2000, 0x80, 0xf0000004, 0xf0000004, 0x1, 0x78060,
				0x78060, 0x0, 0x1, 0x4, 0x0, 0x0, 0x78060, 0x78060, 0x78060,
				0x78060, 0x78060, 0x4, 0x78060, 0x0, 0x1, 0x78060, 0x78060,
				0x78060, };
	}

	/**
	 * Jj_la1_3.
	 */
	private static void jj_la1_3() {
		jj_la1_3 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
				0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
				0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
				0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
				0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
	}

	/** The jj_2_rtns. */
	final private JJCalls[] jj_2_rtns = new JJCalls[7];

	/** The jj_rescan. */
	private boolean jj_rescan = false;

	/** The jj_gc. */
	private int jj_gc = 0;

	/**
	 * Instantiates a new ecma script.
	 * 
	 * @param stream
	 *            the stream
	 */
	public EcmaScript(java.io.InputStream stream) {
		jj_input_stream = new SimpleCharStream(stream, 1, 1);
		token_source = new EcmaScriptTokenManager(jj_input_stream);
		token = new Token();
		jj_ntk = -1;
		jj_gen = 0;
		for (int i = 0; i < 55; i++)
			jj_la1[i] = -1;
		for (int i = 0; i < jj_2_rtns.length; i++)
			jj_2_rtns[i] = new JJCalls();
	}

	/**
	 * Re init.
	 * 
	 * @param stream
	 *            the stream
	 */
	public void ReInit(java.io.InputStream stream) {
		jj_input_stream.ReInit(stream, 1, 1);
		token_source.ReInit(jj_input_stream);
		token = new Token();
		jj_ntk = -1;
		jjtree.reset();
		jj_gen = 0;
		for (int i = 0; i < 55; i++)
			jj_la1[i] = -1;
		for (int i = 0; i < jj_2_rtns.length; i++)
			jj_2_rtns[i] = new JJCalls();
	}

	/**
	 * Instantiates a new ecma script.
	 * 
	 * @param stream
	 *            the stream
	 */
	public EcmaScript(java.io.Reader stream) {
		jj_input_stream = new SimpleCharStream(stream, 1, 1);
		token_source = new EcmaScriptTokenManager(jj_input_stream);
		token = new Token();
		jj_ntk = -1;
		jj_gen = 0;
		for (int i = 0; i < 55; i++)
			jj_la1[i] = -1;
		for (int i = 0; i < jj_2_rtns.length; i++)
			jj_2_rtns[i] = new JJCalls();
	}

	/**
	 * Re init.
	 * 
	 * @param stream
	 *            the stream
	 */
	public void ReInit(java.io.Reader stream) {
		jj_input_stream.ReInit(stream, 1, 1);
		token_source.ReInit(jj_input_stream);
		token = new Token();
		jj_ntk = -1;
		jjtree.reset();
		jj_gen = 0;
		for (int i = 0; i < 55; i++)
			jj_la1[i] = -1;
		for (int i = 0; i < jj_2_rtns.length; i++)
			jj_2_rtns[i] = new JJCalls();
	}

	/**
	 * Instantiates a new ecma script.
	 * 
	 * @param tm
	 *            the tm
	 */
	public EcmaScript(EcmaScriptTokenManager tm) {
		token_source = tm;
		token = new Token();
		jj_ntk = -1;
		jj_gen = 0;
		for (int i = 0; i < 55; i++)
			jj_la1[i] = -1;
		for (int i = 0; i < jj_2_rtns.length; i++)
			jj_2_rtns[i] = new JJCalls();
	}

	/**
	 * Re init.
	 * 
	 * @param tm
	 *            the tm
	 */
	public void ReInit(EcmaScriptTokenManager tm) {
		token_source = tm;
		token = new Token();
		jj_ntk = -1;
		jjtree.reset();
		jj_gen = 0;
		for (int i = 0; i < 55; i++)
			jj_la1[i] = -1;
		for (int i = 0; i < jj_2_rtns.length; i++)
			jj_2_rtns[i] = new JJCalls();
	}

	/**
	 * Jj_consume_token.
	 * 
	 * @param kind
	 *            the kind
	 * 
	 * @return the token
	 * 
	 * @throws ParseException
	 *             the parse exception
	 */
	final private Token jj_consume_token(int kind) throws ParseException {
		Token oldToken;
		if ((oldToken = token).next != null)
			token = token.next;
		else
			token = token.next = token_source.getNextToken();
		jj_ntk = -1;
		if (token.kind == kind) {
			jj_gen++;
			if (++jj_gc > 100) {
				jj_gc = 0;
				for (int i = 0; i < jj_2_rtns.length; i++) {
					JJCalls c = jj_2_rtns[i];
					while (c != null) {
						if (c.gen < jj_gen)
							c.first = null;
						c = c.next;
					}
				}
			}
			return token;
		}
		token = oldToken;
		jj_kind = kind;
		throw generateParseException();
	}

	/**
	 * The Class LookaheadSuccess.
	 */
	static private final class LookaheadSuccess extends java.lang.Error {
	}

	/** The jj_ls. */
	final private LookaheadSuccess jj_ls = new LookaheadSuccess();

	/**
	 * Jj_scan_token.
	 * 
	 * @param kind
	 *            the kind
	 * 
	 * @return true, if successful
	 */
	final private boolean jj_scan_token(int kind) {
		if (jj_scanpos == jj_lastpos) {
			jj_la--;
			if (jj_scanpos.next == null) {
				jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
						.getNextToken();
			} else {
				jj_lastpos = jj_scanpos = jj_scanpos.next;
			}
		} else {
			jj_scanpos = jj_scanpos.next;
		}
		if (jj_rescan) {
			int i = 0;
			Token tok = token;
			while (tok != null && tok != jj_scanpos) {
				i++;
				tok = tok.next;
			}
			if (tok != null)
				jj_add_error_token(kind, i);
		}
		if (jj_scanpos.kind != kind)
			return true;
		if (jj_la == 0 && jj_scanpos == jj_lastpos)
			throw jj_ls;
		return false;
	}

	/**
	 * Gets the next token.
	 * 
	 * @return the next token
	 */
	final public Token getNextToken() {
		if (token.next != null)
			token = token.next;
		else
			token = token.next = token_source.getNextToken();
		jj_ntk = -1;
		jj_gen++;
		return token;
	}

	/**
	 * Gets the token.
	 * 
	 * @param index
	 *            the index
	 * 
	 * @return the token
	 */
	final public Token getToken(int index) {
		Token t = lookingAhead ? jj_scanpos : token;
		for (int i = 0; i < index; i++) {
			if (t.next != null)
				t = t.next;
			else
				t = t.next = token_source.getNextToken();
		}
		return t;
	}

	/**
	 * Jj_ntk.
	 * 
	 * @return the int
	 */
	final private int jj_ntk() {
		if ((jj_nt = token.next) == null)
			return (jj_ntk = (token.next = token_source.getNextToken()).kind);
		else
			return (jj_ntk = jj_nt.kind);
	}

	/** The jj_expentries. */
	private java.util.Vector jj_expentries = new java.util.Vector();

	/** The jj_expentry. */
	private int[] jj_expentry;

	/** The jj_kind. */
	private int jj_kind = -1;

	/** The jj_lasttokens. */
	private int[] jj_lasttokens = new int[100];

	/** The jj_endpos. */
	private int jj_endpos;

	/**
	 * Jj_add_error_token.
	 * 
	 * @param kind
	 *            the kind
	 * @param pos
	 *            the pos
	 */
	private void jj_add_error_token(int kind, int pos) {
		if (pos >= 100)
			return;
		if (pos == jj_endpos + 1) {
			jj_lasttokens[jj_endpos++] = kind;
		} else if (jj_endpos != 0) {
			jj_expentry = new int[jj_endpos];
			for (int i = 0; i < jj_endpos; i++) {
				jj_expentry[i] = jj_lasttokens[i];
			}
			boolean exists = false;
			for (java.util.Enumeration e = jj_expentries.elements(); e
					.hasMoreElements();) {
				int[] oldentry = (int[]) (e.nextElement());
				if (oldentry.length == jj_expentry.length) {
					exists = true;
					for (int i = 0; i < jj_expentry.length; i++) {
						if (oldentry[i] != jj_expentry[i]) {
							exists = false;
							break;
						}
					}
					if (exists)
						break;
				}
			}
			if (!exists)
				jj_expentries.addElement(jj_expentry);
			if (pos != 0)
				jj_lasttokens[(jj_endpos = pos) - 1] = kind;
		}
	}

	/**
	 * Generate parse exception.
	 * 
	 * @return the parses the exception
	 */
	public ParseException generateParseException() {
		jj_expentries.removeAllElements();
		boolean[] la1tokens = new boolean[103];
		for (int i = 0; i < 103; i++) {
			la1tokens[i] = false;
		}
		if (jj_kind >= 0) {
			la1tokens[jj_kind] = true;
			jj_kind = -1;
		}
		for (int i = 0; i < 55; i++) {
			if (jj_la1[i] == jj_gen) {
				for (int j = 0; j < 32; j++) {
					if ((jj_la1_0[i] & (1 << j)) != 0) {
						la1tokens[j] = true;
					}
					if ((jj_la1_1[i] & (1 << j)) != 0) {
						la1tokens[32 + j] = true;
					}
					if ((jj_la1_2[i] & (1 << j)) != 0) {
						la1tokens[64 + j] = true;
					}
					if ((jj_la1_3[i] & (1 << j)) != 0) {
						la1tokens[96 + j] = true;
					}
				}
			}
		}
		for (int i = 0; i < 103; i++) {
			if (la1tokens[i]) {
				jj_expentry = new int[1];
				jj_expentry[0] = i;
				jj_expentries.addElement(jj_expentry);
			}
		}
		jj_endpos = 0;
		jj_rescan_token();
		jj_add_error_token(0, 0);
		int[][] exptokseq = new int[jj_expentries.size()][];
		for (int i = 0; i < jj_expentries.size(); i++) {
			exptokseq[i] = (int[]) jj_expentries.elementAt(i);
		}
		return new ParseException(token, exptokseq, tokenImage);
	}

	/**
	 * Enable_tracing.
	 */
	final public void enable_tracing() {
	}

	/**
	 * Disable_tracing.
	 */
	final public void disable_tracing() {
	}

	/**
	 * Jj_rescan_token.
	 */
	final private void jj_rescan_token() {
		jj_rescan = true;
		for (int i = 0; i < 7; i++) {
			JJCalls p = jj_2_rtns[i];
			do {
				if (p.gen > jj_gen) {
					jj_la = p.arg;
					jj_lastpos = jj_scanpos = p.first;
					switch (i) {
					case 0:
						jj_3_1();
						break;
					case 1:
						jj_3_2();
						break;
					case 2:
						jj_3_3();
						break;
					case 3:
						jj_3_4();
						break;
					case 4:
						jj_3_5();
						break;
					case 5:
						jj_3_6();
						break;
					case 6:
						jj_3_7();
						break;
					}
				}
				p = p.next;
			} while (p != null);
		}
		jj_rescan = false;
	}

	/**
	 * Jj_save.
	 * 
	 * @param index
	 *            the index
	 * @param xla
	 *            the xla
	 */
	final private void jj_save(int index, int xla) {
		JJCalls p = jj_2_rtns[index];
		while (p.gen > jj_gen) {
			if (p.next == null) {
				p = p.next = new JJCalls();
				break;
			}
			p = p.next;
		}
		p.gen = jj_gen + xla - jj_la;
		p.first = token;
		p.arg = xla;
	}

	/**
	 * The Class JJCalls.
	 */
	static final class JJCalls {

		/** The gen. */
		int gen;

		/** The first. */
		Token first;

		/** The arg. */
		int arg;

		/** The next. */
		JJCalls next;
	}
}
